/*
 * Copyright 2010-2012 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.google.code.newpath.core;

import com.google.code.newpath.core.exception.PathException;
import com.google.code.newpath.util.AntPathMatcher;
import com.google.code.newpath.util.PathMatcher;

/**
 * 
 * Store the match pattern for Path. <br/>
 * 
 * includePaths will be used to find the match paths.
 * excludePaths will be used to exclude the match paths which match includePaths.
 * 
 * Each match pattern is ant like path pattern.
 * 
 * @author Charlie Zhang
 * 
 */
public class PathMatchPattern {
	
	private final String[] includePaths;
	
	private final String[] excludePaths;
	
	private final PathMatcher pathMatcher = new AntPathMatcher();
	
	public PathMatchPattern(String[] includePaths, String[] excludePaths) {
		if(includePaths == null || includePaths.length == 0) {
			throw new PathException("Must provide one validate path matchPattern in includePaths!", null);
		}
		
		this.includePaths = includePaths;
		this.excludePaths = excludePaths;
	}
	
	public PathMatchPattern(String[] includePaths) {
		this(includePaths, null);
	}

	public String[] getIncludePaths() {
		return includePaths;
	}

	public String[] getExcludePaths() {
		return excludePaths;
	}
	
	public boolean isMatch(String targetString) {
    	boolean match = false;
    	//find include match 
    	for(String includePath : includePaths) {
    		match = pathMatcher.match(includePath, targetString);
    		if(match == true) { break; }
    	}
    	
    	if(match == true && excludePaths != null) {
    		for(String excludePath : excludePaths) {
    			boolean excludeMatch = pathMatcher.match(excludePath, targetString);
    			if(excludeMatch == true) { 
    				match = false;
    				break; 
    			}
    		}
    	}
    	
    	return match;
	}
	
	public boolean isMatch(Path targetPath) {
		return isMatch(targetPath.getFullPath());
	}
	
}
